/***Intro***/
Intro(2a)

üyû╝æOüz
	Intro - Toolbox: âTâEâôâh(ë╣)è╓ÿAüiman2a.hlpüj

üyèTùvüz

üyè╓ÿAìÇû┌üz

üyInside Macintoshüz
								<<âLü[âÅü[âh>>
	Sound Manager						SoundManager
		VI-22(Part 2)	Sound Manager

	öpÄ~
		V-473		Sound Manager
		

üyâwâbâ_ü[üz
	Sound.h
	SoundInput.h
	MIDI.h

	AIFF.h
	ADSP.h

üyÄcéΦüz
	æSé─
/***SndDoCommand***/ SndDoImmediate SoundManager
SndDoCommand(2a)

üyû╝æOüz
	SndDoCommand   -
	SndDoImmediate -

üyÅæÄ«üz
	üíSndDoCommand		V-479
	üíSndDoImmediate	V-479

	OSErr	SndDoCommand(SndChannelPtr chan, const SndCommand *cmd,
							Boolean noWait);

	OSErr	SndDoImmediate(SndChannelPtr chan, const SndCommand *cmd);
/***SndNewChannel***/ SndDisposeChannel SoundManager
SndNewChannel(2a)

üyû╝æOüz
	SndNewChannel     -
	SndDisposeChannel -

üyÅæÄ«üz
	üíSndNewChannel		V-477
	üíSndDisposeChannel	V-479

	OSErr	SndNewChannel(SndChannelPtr *chan, short synth, long init,
			SndCallBackProcPtr userRoutine);

	OSErr	SndDisposeChannel(SndChannelPtr chan, Boolean quietNow);
/***SndPlay***/ SoundManager
SndPlay(2a)

üyû╝æOüz
	SndPlay -

üyÅæÄ«üz
	üíSndPlay	V-477

	OSErr	SndPlay(SndChannelPtr chan, Handle sndHdl, Boolean async);
/***SndAddModifier***/ SoundManager
SndAddModifier(2a)

üyû╝æOüz
	SndAddModifier -

üyÅæÄ«üz
	üíSndAddModifier	V-478

	OSErr	SndAddModifier(SndChannelPtr chan, ProcPtr modifier, short id,
			long init);
/***SndControl***/ SoundManager
SndControl(2a)

üyû╝æOüz
	SndControl -

üyÅæÄ«üz
	üíSndControl	V-479

	OSErr	SndControl(short id, SndCommand *cmd);
/***SetSoundVol***/ GetSoundVol SoundManager
SetSoundVol(2a)

üyû╝æOüz
	SetSoundVol -
	GetSoundVol -

üyÅæÄ«üz
	üíSetSoundVol	II-233
	üíGetSoundVol	II-232

	void	SetSoundVol(short level);
	void	GetSoundVol(short *level);
/***StartSound***/ StopSound SoundDone SoundManager
StartSound(2a)

üyû╝æOüz
	StartSound -
	StopSound  -
	SoundDone  -

üyÅæÄ«üz
	üíStartSound	II-231
	üíStopSound	II-232
	üíSoundDone	II-232

	void	StartSound(const void *synthRec, long numBytes,
			SndCompletionProcPtr completionRtn);

	void	StopSound(void);

	Boolean	SoundDone(void);
/***SndSoundManagerVersion***/ MACEVersion SPBVersion SoundManager
SndSoundManagerVersion(2a)

üyû╝æOüz
	SndSoundManagerVersion -
	MACEVersion            -
	SPBVersion             -

üyÅæÄ«üz
	NumVersion	SndSoundManagerVersion(void);

	NumVersion	MACEVersion(void);

	NumVersion	SPBVersion(void);
/***SndStartFilePlay***/ SndPauseFilePlay SndStopFilePlay AudioSelection AudioSelectionPtr SoundManager
SndStartFilePlay(2a)

üyû╝æOüz
	SndStartFilePlay -
	SndPauseFilePlay -
	SndStopFilePlay  -
	AudioSelection   - data type

üyÅæÄ«üz
	OSErr	SndStartFilePlay(SndChannelPtr chan, short fRefNum,
			short resNum, long bufferSize, void *theBuffer,
			AudioSelectionPtr theSelection, ProcPtr theCompletion,
			Boolean async);

	OSErr	SndPauseFilePlay(SndChannelPtr chan);
	OSErr	SndStopFilePlay(SndChannelPtr chan, Boolean async);

	üíAudioSelection	??
	  AudioSelection
		long	unitType;
		Fixed	selStart;
		Fixed	selEnd;
	  AudioSelectionPtr	AudioSelection *
/***SndChannelStatus***/ SndManagerStatus SndGetSysBeepState SndSetSysBeepState SCStatus SCStatusPtr SMStatus SMStatusPtr SoundManager
SndChannelStatus(2a)

üyû╝æOüz
	SndChannelStatus   -
	SndManagerStatus   -
	SndGetSysBeepState -
	SndSetSysBeepState -
	SCStatus           - data type
	SMStatus           - data type

üyÅæÄ«üz
	OSErr	SndChannelStatus(SndChannelPtr chan, short theLength,
			SCStatusPtr theStatus);

	OSErr	SndManagerStatus(short theLength, SMStatusPtr theStatus);

	void	SndGetSysBeepState(short *sysBeepState);

	OSErr	SndSetSysBeepState(short sysBeepState);

	üíSCStatus	??
	  SCStatus
		Fixed	scStartTime;
		Fixed	scEndTime;
		Fixed	scCurrentTime;
		Boolean scChannelBusy;
		Boolean scChannelDisposed;
		Boolean scChannelPaused;
		Boolean scUnused;
		unsigned long scChannelAttributes;
		long	scCPULoad;
	  SCStatusPtr	SCStatus *

	üíSMStatus	??
	  SMStatus
		short	smMaxCPULoad;
		short	smNumChannels;
		short	smCurCPULoad;
	  SMStatusPtr	SMStatus *
/***SndPlayDoubleBuffer***/ SndDoubleBuffer SndDoubleBufferPtr SndDoubleBufferHeader SndDoubleBufferHeaderPtr SoundManager
SndPlayDoubleBuffer(2a)

üyû╝æOüz
	SndPlayDoubleBuffer   -
	SndDoubleBuffer       - data type
	SndDoubleBufferHeader - data type

üyÅæÄ«üz
	OSErr	SndPlayDoubleBuffer(SndChannelPtr chan,
			SndDoubleBufferHeaderPtr theParams);


	üíSndDoubleBuffer	??
	  SndDoubleBuffer
		long	dbNumFrames;
		long	dbFlags;
		long	dbUserInfo[2];
		char	dbSoundData[1];
	  SndDoubleBufferPtr	SndDoubleBuffer *

	üíSndDoubleBufferHeader	??
	  SndDoubleBufferHeader
		short		dbhNumChannels;
		short		dbhSampleSize;
		short		dbhCompressionID;
		short		dbhPacketSize;
		Fixed		dbhSampleRate;
		SndDoubleBufferPtr   dbhBufferPtr[2];
		SndDoubleBackProcPtr dbhDoubleBack;
	  SndDoubleBufferHeaderPtr	SndDoubleBufferHeader *
/***Comp3to1***/ Exp1to3 Comp6to1 Exp1to6 SoundManager
Comp3to1(2a)

üyû╝æOüz
	Comp3to1 -
	Exp1to3  -
	Comp6to1 -
	Exp1to6  -

üyÅæÄ«üz
	void	Comp3to1(const void *inBuffer, void *outBuffer,
			unsigned long cnt, const void *inState, void *outState,
			unsigned long numChannels, unsigned long whichChannel);
	void	Exp1to3(const void *inBuffer, void *outBuffer,
			unsigned long cnt, const void *inState, void *outState,
			unsigned long numChannels, unsigned long whichChannel);
	void	Comp6to1(const void *inBuffer, void *outBuffer,
			unsigned long cnt, const void *inState, void *outState,
			unsigned long numChannels, unsigned long whichChannel);
	void	Exp1to6(const void *inBuffer, void *outBuffer,
			unsigned long cnt, const void *inState, void *outState,
			unsigned long numChannels, unsigned long whichChannel);
/***FFSynthRec***/ FFSynthPtr FreeWave SoundManager
FFSynthRec(2a)

üyû╝æOüz
	FFSynthRec -

üyÅæÄ«üz
	üíFFSynthRec	II-228
	üíFreeWave	II-228

	  FFSynthRec
		short	mode;
		Fixed	count;
		FreeWave waveBytes;
	  FFSynthPtr	FFSynthRec *

	  FreeWave	unsigned char	[30001]
/***Tone***/ Tones SoundManager
Tone(2a)

üyû╝æOüz
	Tone -

üyÅæÄ«üz
	üíTone	II-225
	  Tone
		short	count;
		short	amplitude;
		short	duration;
	  Tones	Tone	[5001]
/***SWSynthRec***/ SWSynthPtr SoundManager
SWSynthRec(2a)

üyû╝æOüz
	SWSynthRec -

üyÅæÄ«üz
	üíSWSynthRec	II-225
	  SWSynthRec
		short	mode;
		Tones	triplets;

	  SWSynthPtr	SWSynthRec *
/***Wave***/ SoundManager
	Wave	II-227
	Wave	unsigned char	[256]
	WavePtr	Wave *
/***FTSoundRec***/ FTSndRecPtr SoundManager
FTSoundRec(2a)

üyû╝æOüz
	FTSoundRec -

üyÅæÄ«üz
	üíFTSoundRec	II-227
	  FTSoundRec
		short	duration;
		Fixed	sound1Rate;
		long	sound1Phase;
		Fixed	sound2Rate;
		long	sound2Phase;
		Fixed	sound3Rate;
		long	sound3Phase;
		Fixed	sound4Rate;
		long	sound4Phase;
		WavePtr sound1Wave;
		WavePtr sound2Wave;
		WavePtr sound3Wave;
		WavePtr sound4Wave;
	  FTSndRecPtr	FTSoundRec *
/***FTSynthRec***/ FTSynthPtr SoundManager
FTSynthRec(2a)

üyû╝æOüz
	FTSynthRec -

üyÅæÄ«üz
	üíFTSynthRec	II-227
	  FTSynthRec
		short		mode;
		FTSndRecPtr	sndRec;
	  FTSynthPtr	FTSynthRec *
/***SndCommand***/ SoundManager
SndCommand(2a)

üyû╝æOüz
	SndCommand -

üyÅæÄ«üz
	üíSndCommand	V-483
	  SndCommand
		unsigned short	cmd;
		short		param1;
		long		param2;
/***SndChannel***/ SndChannelPtr SoundManager
SndChannel(2a)

üyû╝æOüz
	SndChannel -

üyÅæÄ«üz
	üíSndChannel	V-477, 481
	  SndChannel
		struct	SndChannel *nextChan;
		Ptr	firstMod;
		SndCallBackProcPtr callBack;
		long	userInfo;
		long	wait;
		SndCommand cmdInProgress;
		short	flags;
		short	qLength;
		short	qHead;
		short	qTail;
		SndCommand queue[stdQLength];
	  SndChannelPtr	SndChannel *
/***SndListResource***/ SndListPtr ModRef SoundManager
SndListResource(2a)

üyû╝æOüz
	SndListResource -
	ModRef          -

üyÅæÄ«üz
	üíSndListResource	??
	  SndListResource
		short		format;
		short		numModifiers;
		ModRef		modifierPart[1];
		short		numCommands;
		SndCommand	commandPart[1];
		char		dataPart[1];
	  SndListPtr	SndListResource *

	üíModRef	??
	  ModRef
		unsigned short	modNumber;
		long		modInit;
/***SoundHeader***/ SoundHeaderPtr CmpSoundHeader CmpSoundHeaderPtr ExtSoundHeader ExtSoundHeaderPtr StateBlock StateBlockPtr LeftOverBlock LeftOverBlockPtr SoundManager
SoundHeader(2a)

üyû╝æOüz
	SoundHeader    -
	CmpSoundHeader -
	ExtSoundHeader -
	StateBlock     -
	LeftOverBlock  -

üyÅæÄ«üz
	üíSoundHeader	??
	  SoundHeader
		Ptr		samplePtr;
		unsigned long	length;
		Fixed		sampleRate;
		unsigned long	loopStart;
		unsigned long	loopEnd;
		unsigned char	encode;
		unsigned char	baseFrequency;
		char		sampleArea[1];
	  SoundHeaderPtr	SoundHeader *

	üíCmpSoundHeader	??
	  CmpSoundHeader
		Ptr		samplePtr;
		unsigned long	numChannels;
		Fixed		sampleRate;
		unsigned long	loopStart;
		unsigned long	loopEnd;
		unsigned char	encode;
		unsigned char	baseFrequency;
		unsigned long	numFrames;
		extended	AIFFSampleRate;
		Ptr		markerChunk;
		Ptr		futureUse1;
		Ptr		futureUse2;
		StateBlockPtr	stateVars;
		LeftOverBlockPtr leftOverSamples;
		unsigned short	compressionID;
		unsigned short	packetSize;
		unsigned short	snthID;
		unsigned short	sampleSize;
		char		sampleArea[1];
	  CmpSoundHeaderPtr	CmpSoundHeader *

	üíExtSoundHeader	??
	  ExtSoundHeader
		Ptr		samplePtr;
		unsigned long	numChannels;
		Fixed		sampleRate;
		unsigned long	loopStart;
		unsigned long	loopEnd;
		unsigned char	encode;
		unsigned char	baseFrequency;
		unsigned long	numFrames;
		extended	AIFFSampleRate;
		Ptr		markerChunk;
		Ptr		instrumentChunks;
		Ptr		AESRecording;
		unsigned short	sampleSize;
		unsigned short	futureUse1;
		unsigned long	futureUse2;
		unsigned long	futureUse3;
		unsigned long	futureUse4;
		char		sampleArea[1];
	  ExtSoundHeaderPtr	ExtSoundHeader *

	üíStateBlock	??
	  StateBlock
		short	stateVar[stateBlockSize];
	  StateBlockPtr	StateBlock *

	üíLeftOverBlock	??
	  LeftOverBlock
		unsigned long	count;
		char		sampleArea[leftOverBlockSize];
	  LeftOverBlockPtr	LeftOverBlock *
/***ConversionBlock***/ ConversionBlockPtr SoundManager
ConversionBlock(2a)

üyû╝æOüz
	ConversionBlock -

üyÅæÄ«üz
	üíConversionBlock	??
	  ConversionBlock
		short	destination;
		short	unused;
		CmpSoundHeaderPtr inputPtr;
		CmpSoundHeaderPtr outputPtr;
	  ConversionBlockPtr	ConversionBlock *
#
#
#
/***SndRecord***/ SndRecordToFile
SndRecord(2a)

üyû╝æOüz
	SndRecord       -
	SndRecordToFile -

üyÅæÄ«üz
	OSErr	SndRecord(ModalFilterProcPtr filterProc, Point corner,
			OSType quality, Handle *sndHandle);

	OSErr	SndRecordToFile(ModalFilterProcPtr filterProc, Point corner,
			OSType quality, short fRefNum);
/***SPBSignInDevice***/ SPBSignOutDevice SPBGetIndexedDevice SPBOpenDevice SPBCloseDevice
SPBSignInDevice(2a)

üyû╝æOüz
	SPBSignInDevice     -
	SPBSignOutDevice    -
	SPBGetIndexedDevice -
	SPBOpenDevice       -
	SPBCloseDevice      -

üyÅæÄ«üz
	OSErr	SPBSignInDevice(short deviceRefNum, Str255 deviceName);

	OSErr	SPBSignOutDevice(short deviceRefNum);

	OSErr	SPBGetIndexedDevice(short count, Str255 deviceName,
			Handle *deviceIconHandle);

	OSErr	SPBOpenDevice(ConstStr255Param deviceName, short permission,
			long *inRefNum);

	OSErr	SPBCloseDevice(long inRefNum);
/***SPBRecord***/ SPBRecordToFile SPBPauseRecording SPBResumeRecording SPBStopRecording SPBGetRecordingStatus SPB SPBPtr
SPBRecord(2a)

üyû╝æOüz
	SPBRecord             -
	SPBRecordToFile       -
	SPBPauseRecording     -
	SPBResumeRecording    -
	SPBStopRecording      -
	SPBGetRecordingStatus -
	SPB                   - data type

üyÅæÄ«üz
	OSErr	SPBRecord(SPBPtr inParamPtr, Boolean asynchFlag);

	OSErr	SPBRecordToFile(short fileRefNum, SPBPtr inParamPtr,
			Boolean asynchFlag);

	OSErr	SPBPauseRecording(long inRefNum);

	OSErr	SPBResumeRecording(long inRefNum);

	OSErr	SPBStopRecording(long inRefNum);

	OSErr	SPBGetRecordingStatus(long inRefNum, short *recordingStatus,
			short *meterLevel, ulong *totalSamplesToRecord,
			ulong *numberOfSamplesRecorded,
			ulong *totalMsecsToRecord,
			ulong *numberOfMsecsRecorded );

	üíSPB	??
	  SPB
		long	inRefNum;
		ulong	count;
		ulong	milliseconds;
		ulong	bufferLength;
		Ptr	bufferPtr;
		ProcPtr	completionRoutine;
		ProcPtr	interruptRoutine;
		long	userLong;
		OSErr	error;
		long	unused1;
/***SPBGetDeviceInfo***/ SPBSetDeviceInfo
SPBGetDeviceInfo(2a)

üyû╝æOüz
	SPBGetDeviceInfo -
	SPBSetDeviceInfo -

üyÅæÄ«üz
	OSErr	SPBGetDeviceInfo(long inRefNum, OSType infoType,
			char *infoData);

	OSErr	SPBSetDeviceInfo(long inRefNum, OSType infoType,
			char *infoData);
/***SPBMillisecondsToBytes***/ SPBBytesToMilliseconds
SPBMillisecondsToBytes(2a)

üyû╝æOüz
	SPBMillisecondsToBytes -
	SPBBytesToMilliseconds -

üyÅæÄ«üz
	OSErr	SPBMillisecondsToBytes(long inRefNum, long *milliseconds);

	OSErr	SPBBytesToMilliseconds(long inRefNum, long *byteCount);
/***SetupSndHeader***/ SetupAIFFHeader
SetupSndHeader(2a)

üyû╝æOüz
	SetupSndHeader -
	SetupAIFFHeader -

üyÅæÄ«üz
	OSErr	SetupSndHeader(Handle sndH, short numChannels,
			Fixed sampleRate, short sampleSize,
			OSType compressionType, short baseNote, ulong numBytes,
			short *headerLen);

	OSErr	SetupAIFFHeader(short fRefNum, short numChannels,
			Fixed sampleRate, short sampleSize,
			OSType compressionType, ulong numBytes,
			ulong numFrames);
#
#
#
/***SndDispVersion***/
SndDispVersion(2a)

üyû╝æOüz
	SndDispVersion -

	long	SndDispVersion(short toolnum);
/***MIDISignIn***/ MIDISignOut
MIDISignIn(2a)

üyû╝æOüz
	MIDISignIn  -
	MIDISignOut -

	OSErr	MIDISignIn(OSType clientID, long refCon, Handle icon,
			ConstStr255Param name);

	void	MIDISignOut(OSType clientID);
/***MIDIGetClients***/ MIDIGetClientName MIDISetClientName
MIDIGetClients(2a)

üyû╝æOüz
	MIDIGetClients    -
	MIDIGetClientName -
	MIDISetClientName -

	MIDIIDListHdl	MIDIGetClients(void);

	void	MIDIGetClientName(OSType clientID, Str255 name);

	void	MIDISetClientName(OSType clientID, ConstStr255Param name);
/***MIDIGetPorts***/ MIDIAddPort MIDIGetPortInfo MIDIGetPortName MIDISetPortName
MIDIGetPorts(2a)

üyû╝æOüz
	MIDIGetPorts    -
	MIDIAddPort     -
	MIDIGetPortInfo -
	MIDIGetPortName -
	MIDISetPortName -

	MIDIIDListHdl	MIDIGetPorts(OSType clientID);

	OSErr	MIDIAddPort(OSType clientID, short BufSize, short *refnum,
			MIDIPortParamsPtr init);

	MIDIPortInfoHdl	MIDIGetPortInfo(OSType clientID, OSType portID);

	void	MIDIGetPortName(OSType clientID, OSType portID, Str255 name);
	void	MIDISetPortName(OSType clientID, OSType portID,
							ConstStr255Param name);
/***MIDIConnectData***/ MIDIUnConnectData MIDIConnectTime MIDIUnConnectTime
MIDIConnectData(2a)

üyû╝æOüz
	MIDIConnectData   -
	MIDIUnConnectData -
	MIDIConnectTime   -
	MIDIUnConnectTime -

	OSErr	MIDIConnectData(OSType srcClID, OSType srcPortID,
			OSType dstClID, OSType dstPortID);

	OSErr	MIDIUnConnectData(OSType srcClID, OSType srcPortID,
			OSType dstClID, OSType dstPortID);

	OSErr	MIDIConnectTime(OSType srcClID, OSType srcPortID,
			OSType dstClID, OSType dstPortID);

	OSErr	MIDIUnConnectTime(OSType srcClID, OSType srcPortID,
			OSType dstClID, OSType dstPortID);
/***MIDIFlush***/
MIDIFlush(2a)

üyû╝æOüz
	MIDIFlush -

	void	MIDIFlush(short refnum);
/***MIDIGetReadHook***/ MIDISetReadHook
MIDIGetReadHook(2a)

üyû╝æOüz
	MIDIGetReadHook -
	MIDISetReadHook -

	ProcPtr	MIDIGetReadHook(short refnum);

	void	MIDISetReadHook(short refnum, ProcPtr hook);
/***MIDIWakeUp***/ MIDIRemovePort MIDIGetSync MIDISetSync
MIDIWakeUp(2a)

	MIDIWakeUp -
	MIDIRemovePort -
	MIDIGetSync -
	MIDISetSync -

	void	MIDIWakeUp(short refnum, long time, long period,
			ProcPtr timeProc);

	void	MIDIRemovePort(short refnum);

	short	MIDIGetSync(short refnum);

	void	MIDISetSync(short refnum, short sync);
/***MIDIGetCurTime***/ MIDISetCurTime MIDIStartTime MIDIStopTime
MIDIGetCurTime(2a)

	MIDIGetCurTime -
	MIDISetCurTime -
	MIDIStartTime  -
	MIDIStopTime   -

	long	MIDIGetCurTime(short refnum);

	void	MIDISetCurTime(short refnum, long time);

	void	MIDIStartTime(short refnum);

	void	MIDIStopTime(short refnum);
/***MIDIPoll***/
MIDIPoll(2a)

	MIDIPoll -

	void	MIDIPoll(short refnum, long offsetTime);
/***MIDIWritePacket***/
MIDIWritePacket(2a)

	MIDIWritePacket -

	OSErr	MIDIWritePacket(short refnum, MIDIPacketPtr packet);
/***MIDIWorldChanged***/
MIDIWorldChanged(2a)

	MIDIWorldChanged -

	Boolean	MIDIWorldChanged(OSType clientID);
/***MIDIGetOffsetTime***/ MIDISetOffsetTime MIDIConvertTime
MIDIGetOffsetTime(2a)

	MIDIGetOffsetTime -
	MIDISetOffsetTime -
	MIDIConvertTime   -

	long	MIDIGetOffsetTime(short refnum);

	void	MIDISetOffsetTime(short refnum, long offsetTime);

	long	MIDIConvertTime(short srcFormat, short dstFormat, long time);
/***MIDIGetRefCon***/ MIDISetRefCon MIDIGetClRefCon MIDISetClRefCon MIDIGetTCFormat MIDISetTCFormat
MIDIGetRefCon(2a)

	MIDIGetRefCon   -
	MIDISetRefCon   -
	MIDIGetClRefCon -
	MIDISetClRefCon -
	MIDIGetTCFormat -
	MIDISetTCFormat -

	long	MIDIGetRefCon(short refnum);
	void	MIDISetRefCon(short refnum, long refCon);

	long	MIDIGetClRefCon(OSType clientID);
	void	MIDISetClRefCon(OSType clientID, long refCon);

	short	MIDIGetTCFormat(short refnum);

	void	MIDISetTCFormat(short refnum, short format);
/***MIDISetRunRate***/
MIDISetRunRate(2a)

	MIDISetRunRate -

	void	MIDISetRunRate(short refnum, short rate, long time);
/***MIDIGetClientIcon***/
MIDIGetClientIcon(2a)

	MIDIGetClientIcon -

	Handle	MIDIGetClientIcon(OSType clientID);
/***MIDIPacket***/ MIDIPacketPtr
MIDIPacket(2a)

üyû╝æOüz
	MIDIPacket -

üyî`Ä«üz
	üíMIDIPacket	??
	  MIDIPacket
		uchar	flags;
		uchar	len;
		long	tStamp;
		uchar	data[249];
	  MIDIPacketPtr	MIDIPacket *
/***MIDIClkInfo***/
MIDIClkInfo(2a)

üyû╝æOüz
	MIDIClkInfo -

üyî`Ä«üz
	üíMIDIClkInfo	??
	  MIDIClkInfo
		short	sync;
		long	curTime;
		short	format;
/***MIDIIDRec***/
MIDIIDRec(2a)

üyû╝æOüz
	MIDIIDRec -

üyî`Ä«üz
	üíMIDIIDRec	??
	  MIDIIDRec
		OSType	clientID;
		OSType	portID;
/***MIDIPortInfo***/ MIDIPortInfoPtr MIDIPortInfoHdl
MIDIPortInfo(2a)

üyû╝æOüz
	MIDIPortInfo -

üyî`Ä«üz
	üíMIDIPortInfo	??
	  MIDIPortInfo
		short		portType;
		MIDIIDRec	timeBase;
		short		numConnects;
		MIDIIDRec	cList[1];

	  MIDIPortInfoPtr	MIDIPortInfo *
	  MIDIPortInfoHdl	MIDIPortInfo **
/***MIDIPortParams***/ MIDIPortParamsPtr
MIDIPortParams(2a)

üyû╝æOüz
	MIDIPortParams -

üyî`Ä«üz
	üíMIDIPortParams	??

	  MIDIPortParams
		OSType		portID;
		short		portType;
		short		timeBase;
		long		offsetTime;
		Ptr		readHook;
		long		refCon;
		MIDIClkInfo	initClock;
		Str255		name;
	  MIDIPortParamsPtr	MIDIPortParams *
/***MIDIIDList***/ MIDIIDListPtr MIDIIDListHdl
MIDIIDList(2a)

üyû╝æOüz
	MIDIIDList -

üyî`Ä«üz
	üíMIDIIDList	??
	  MIDIIDList
		short	numIDs;
		OSType	list[1];

	  MIDIIDListPtr	MIDIIDList *
	  MIDIIDListHdl	MIDIIDList **
#
#
#
/***ID***/ MarkerIdType
	ID	??
		ID	ulong

	MarkerIdType	??
		MarkerIdType	short
/***ChunkHeader***/
ChunkHeader(2a)

üyû╝æOüz
	ChunkHeader -

üyî`Ä«üz
	üíChunkHeader	??
	  ChunkHeader
		ID		ckID;
		long		ckSize;
/***ContainerChunk***/
ContainerChunk(2a)

üyû╝æOüz
	ContainerChunk -

üyî`Ä«üz
	üíContainerChunk	??
	  ContainerChunk
		ID		ckID;
		long		ckSize;
		ID		formType;
/***FormatVersionChunk***/ FormatVersionChunkPtr
FormatVersionChunk(2a)

üyû╝æOüz
	FormatVersionChunk -

üyî`Ä«üz
	üíFormatVersionChunk	??
	  FormatVersionChunk
		ID		ckID;
		long		ckSize;
		ulong		timestamp;
/***CommonChunk***/ CommonChunkPtr ExtCommonChunk ExtCommonChunkPtr
CommonChunk(2a)

üyû╝æOüz
	CommonChunk    -
	ExtCommonChunk -

üyî`Ä«üz
	üíCommonChunk	??
	  CommonChunk
		ID		ckID;
		long		ckSize;
		short		numChannels;
		ulong		numSampleFrames;
		short		sampleSize;
		extended	sampleRate;

	üíExtCommonChunk	??
	  ExtCommonChunk
		ID		ckID;
		long		ckSize;
		short		numChannels;
		ulong		numSampleFrames;
		short		sampleSize;
		extended	sampleRate;
		ID		compressionType;
		char		compressionName[1];
/***SoundDataChunk***/ SoundDataChunkPtr
SoundDataChunk(2a)

üyû╝æOüz
	SoundDataChunk -

üyî`Ä«üz
	üíSoundDataChunk	??
	  SoundDataChunk
		ID		ckID;
		long		ckSize;
		ulong		offset;
		ulong		blockSize;
/***Marker***/ MarkerChunk MarkerChunkPtr
Marker(2a)

üyû╝æOüz
	Marker      -
	MarkerChunk -

üyî`Ä«üz
	üíMarker	??
	  Marker
		MarkerIdType	id;
		ulong		position;
		Str255		markerName;

	üíMarkerChunk	??
	  MarkerChunk
		ID		ckID;
		long		ckSize;
		ushort		numMarkers;
		Marker		Markers[1];

	  MarkerChunkPtr	MakerChunk *
/***AIFFLoop***/
AIFFLoop(2a)

üyû╝æOüz
	AIFFLoop -

üyî`Ä«üz
	üíAIFFLoop	??

	  AIFFLoop
		short		playMode;
		MarkerIdType	beginLoop;
		MarkerIdType	endLoop;
/***InstrumentChunk***/ InstrumentChunkPtr
InstrumentChunk(2a)

üyû╝æOüz
	InstrumentChunk -

üyî`Ä«üz
	üíInstrumentChunk	??
	  InstrumentChunk
		ID		ckID;
		long		ckSize;
		char		baseFrequency;
		char		detune;
		char		lowFrequency;
		char		highFrequency;
		char		lowVelocity;
		char		highVelocity;
		short		gain;
		AIFFLoop	sustainLoop;
		AIFFLoop	releaseLoop;
/***MIDIDataChunk***/ MIDIDataChunkPtr
MIDIDataChunk(2a)

üyû╝æOüz
	MIDIDataChunk -

üyî`Ä«üz
	üíMIDIDataChunk	??
	  MIDIDataChunk
		ID		ckID;
		long		ckSize;
		uchar		MIDIdata[1];
/***AudioRecordingChunk***/ AudioRecordingChunkPtr
AudioRecordingChunk(2a)

üyû╝æOüz
	AudioRecordingChunk -

üyî`Ä«üz
	üíAudioRecordingChunk	??
	  AudioRecordingChunk
		ID		ckID;
		long		ckSize;
		uchar		AESChannelStatus[24];
/***ApplicationSpecificChunk***/ ApplicationSpecificChunkPtr
ApplicationSpecificChunk(2a)

üyû╝æOüz
	ApplicationSpecificChunk -

üyî`Ä«üz
	üíApplicationSpecificChunk	??
	  ApplicationSpecificChunk
		ID		ckID;
		long		ckSize;
		OSType		applicationSignature;
		char		data[1];
/***Comment***/ CommentsChunk CommentsChunkPtr
Comment(2a)

üyû╝æOüz
	Comment       -
	CommentsChunk -

üyî`Ä«üz
	üíComment	??
	  Comment
		ulong		timeStamp;
		MarkerIdType	marker;
		ushort		count;
		char		text[1];

	üíCommentsChunk	??
	  CommentsChunk
		ID	ckID;
		long	ckSize;
		ushort	numComments;
		Comment	comments[1];
/***TextChunk***/ TextChunkPtr
TextChunk(2a)

üyû╝æOüz
	TextChunk -

üyî`Ä«üz
	üíTextChunk	??
	  TextChunk
		ID	ckID;
		long	ckSize;
		char	text[1];

	  TextChunkPtr	TextChunk *
#
#
#
/***TRCCB***/ TPCCB
TRCCB(2a)

üyû╝æOüz
	TRCCB -

üyî`Ä«üz
	üíTRCCB	??
	  TRCCB
		uchar	*ccbLink;
		ushort	refNum;
		ushort	state;
		uchar	userFlags;
		uchar	localSocket;
		AddrBlock remoteAddress;
		ushort	attnCode;
		ushort	attnSize;
		uchar	*attnPtr;
		uchar	reserved[220];

	  TPCCB	TRCCB *
/***TRinitParams***/
TRinitParams(2a)

üyû╝æOüz
	TRinitParams -

üyî`Ä«üz
	üíTRinitParams	??
	  TRinitParams
		TPCCB	ccbPtr;
		ProcPtr	userRoutine;
		ushort	sendQSize;
		uchar	*sendQueue;
		ushort	recvQSize;
		uchar	*recvQueue;
		uchar	*attnPtr;
		uchar	localSocket;
/***TRopenParams***/
TRopenParams(2a)

üyû╝æOüz
	TRopenParams -

üyî`Ä«üz
	üíTRopenParams	??
	  TRopenParams
		ushort		localCID;
		ushort		remoteCID;
		AddrBlock	remoteAddress;/* address of remote end */
		AddrBlock	filterAddress;/* address filter */
		ulong		sendSeq;
		ushort		sendWindow;
		ulong		recvSeq;
		ulong		attnSendSeq;
		ulong		attnRecvSeq;
		uchar		ocMode;
		uchar		ocInterval;
		uchar		ocMaximum;
/***TRcloseParams***/
TRcloseParams(2a)

üyû╝æOüz
	TRcloseParams -

üyî`Ä«üz
	üíTRcloseParams	??

	  TRcloseParams
		uchar	abort;
/***TRstatusParams***/
TRstatusParams(2a)

üyû╝æOüz
	TRstatusParams -

üyî`Ä«üz
	üíTRstatusParams	??
	  TRstatusParams
		TPCCB	ccbPtr;
		ushort	sendQPending;
		ushort	sendQFree;
		ushort	recvQPending;
		ushort	recvQFree;
/***TRioParams***/
TRioParams(2a)

üyû╝æOüz
	TRioParams -

üyî`Ä«üz
	üíTRioParams	??
	  TRioParams
		ushort	reqCount;
		ushort	actCount;
		uchar	*dataPtr;
		uchar	eom;
		uchar	flush;
/***TRattnParams***/
TRattnParams(2a)

üyû╝æOüz
	TRattnParams -

üyî`Ä«üz
	üíTRattnParams	??
	  TRattnParams
		ushort	attnCode;
		ushort	attnSize;
		uchar	*attnData;
		uchar	attnInterval;
/***TRoptionParams***/
TRoptionParams(2a)

üyû╝æOüz
	TRoptionParams -

üyî`Ä«üz
	üíTRoptionParams	??
	  TRoptionParams
		ushort	sendBlocking;
		uchar	sendTimer;
		uchar	rtmtTimer;
		uchar	badSeqMax;
		uchar	useCheckSum;
/***TRnewcidParams***/
TRnewcidParams(2a)

üyû╝æOüz
	TRnewcidParams -

üyî`Ä«üz
	üíTRnewcidParams	??
	  TRnewcidParams
		ushort	newcid;
/***DSPParamBlock***/ DSPPBPtr
DSPParamBlock(2a)

üyû╝æOüz
	DSPParamBlock -

üyî`Ä«üz
	üíDSPParamBlock	??
	  DSPParamBlock
		struct	QElem	*qLink;
		short	qType;
		short	ioTrap;
		Ptr	ioCmdAddr;
		ProcPtr	ioCompletion;
		OSErr	ioResult;
		char	*ioNamePtr;
		short	ioVRefNum;
		short	ioCRefNum;
		short	acsCode;
		long	qStatus;
		short	ccbRefNum;
		union {
			TRinitParams	initParams;
			TRopenParams	openParams;
			TRcloseParams	closeParams;
			TRioParams	ioParams;
			TRattnParams	attnParams;
			TRstatusParams	statusParams;
			TRoptionParams	optionParams;
			TRnewcidParams	newCIDParams;
		}	u;

	  DSPPBPtr	struct DSPParamBlock *
